package com.zhou.designParten.demo;


import org.springframework.util.SerializationUtils;

import java.io.Serializable;
import java.lang.reflect.Constructor;

/**
 * 单例模式
 * 属于：创建型模式-对象创建型模式
 * 定义：一个类只有一个实例，且该类能自行创建这个实例的一种模式
 * 应用场景:节省内存，保持对象数据一致性
 * 实现： 懒汉式 饿汗式 静态内部类  枚举方式
 */
public class Singleton {

}

//懒汉式  类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例
//注意：如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。
// 如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。
class LazySingleton{
    private static volatile LazySingleton instance=null;    //保证 instance 在所有线程中同步
    private LazySingleton(){}    //private 避免类在外部被实例化
    public static synchronized LazySingleton getInstance() {
        //getInstance 方法前加同步
        if(instance==null)
        {
            instance = new LazySingleton();
        }
        return instance;
    }
}


//饿汉式单例 类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了
//饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题
class HungrySingleton {
    private static final HungrySingleton instance=new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance()
    {
        return instance;
    }
}

//静态内部类方式
//似乎静态内部类看起来已经是最完美的方法了，其实不是，可能还存在反射攻击或者反序列化攻击。
class InsideSingleton implements Serializable {
    private static class SingletonHolder{
        private static InsideSingleton instance = new InsideSingleton();
    }

    private InsideSingleton(){}

    public static InsideSingleton getInstance(){
        return SingletonHolder.instance;
    }

    public static void main(String[] args) throws Exception {
        //反射攻击
        InsideSingleton singleton = InsideSingleton.getInstance();
        Constructor<InsideSingleton> constructor = InsideSingleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        InsideSingleton newSingleton = constructor.newInstance();
        System.out.println(singleton == newSingleton); //返回false
        //反序列化
        byte[] serialize = SerializationUtils.serialize(singleton);
        InsideSingleton newInstance = (InsideSingleton) SerializationUtils.deserialize(serialize);
        System.out.println(singleton == newInstance); //返回false
    }

}

//枚举方式  如果通过反射攻击会报错,反序列化会返回true,也没有线程安全问题，完美的单例模式
enum  EnumSingleton implements Serializable{
    INSTANCE;

    public void doSomething(){
        System.out.println("do something");
    }

    public static void main(String[] args){
        EnumSingleton instance = EnumSingleton.INSTANCE;
        byte[] serialize = SerializationUtils.serialize(instance);
        EnumSingleton newInstance = (EnumSingleton) SerializationUtils.deserialize(serialize);
        System.out.println(newInstance == newInstance); //返回true
    }
}
